package cn.tedu.user.management.dao.persist.repository.impl;

import cn.tedu.rtms.commons.pojo.vo.PageData;
import cn.tedu.rtms.commons.util.PageInfoToPageDataConverter;
import cn.tedu.user.management.dao.persist.mapper.SectionMapper;
import cn.tedu.user.management.dao.persist.mapper.UserMapper;
import cn.tedu.user.management.dao.persist.repository.ISectionRepository;
import cn.tedu.user.management.pojo.entity.Section;
import cn.tedu.user.management.pojo.entity.User;
import cn.tedu.user.management.pojo.vo.SectionListItemVO;
import cn.tedu.user.management.pojo.vo.SectionStandardVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * 处理部门数据的数据访问实现类
 *
 * @author java@tedu.cn
 * @version 0.0.1
 */
@Slf4j
@Repository
public class SectionRepositoryImpl implements ISectionRepository {

    @Autowired
    private SectionMapper sectionMapper;

    @Autowired
    private UserMapper userMapper;

    public SectionRepositoryImpl() {
        log.debug("创建数据访问实现类对象：SectionRepositoryImpl");
    }

    @Override
    public int insert(Section section) {
        log.debug("开始执行【插入部门】的数据访问，参数：{}", section);
        return sectionMapper.insert(section);
    }
    /*
    @Override
    public int insertBatch(List<Section> sectionList) {
        log.debug("开始执行【批量插入部门】的数据访问，参数：{}", sectionList);
        return sectionMapper.insertBatch(sectionList);
    }*/

    @Override
    public int deleteById(Long id) {
        log.debug("开始执行【根据ID删除部门】的数据访问，参数：{}", id);
        return sectionMapper.deleteById(id);
    }

    /*@Override
    public int deleteByIds(Collection<Long> idList) {
        log.debug("开始执行【批量删除部门】的数据访问，参数：{}", idList);
        return sectionMapper.deleteBatchIds(idList);
    }*/

    /*@Override
    public int updateById(Section section) {
        log.debug("开始执行【更新部门】的数据访问，参数：{}", section);
        return sectionMapper.updateById(section);
    }*/

    /*@Override
    public int count() {
        log.debug("开始执行【统计部门的数量】的数据访问，参数：无");
        return sectionMapper.selectCount(null);
    }*/

    @Override
    public int countBySectionName(String sectionName) {
        log.debug("开始执行【根据部门名统计部门的数量】的数据访问，参数：{}", sectionName);
        QueryWrapper<Section> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("section_name", sectionName);
        return sectionMapper.selectCount(queryWrapper);
    }

    @Override
    public int countByRealName(String realName) {
        log.debug("开始执行【根据员工姓名查询数量】的数据访问，参数：{}", realName);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("real_name", realName);
        return userMapper.selectCount(queryWrapper);
    }

   /* @Override
    public int countByPhone(String phone) {
        log.debug("开始执行【根据手机号码统计部门的数量】的数据访问，参数：{}", phone);
        QueryWrapper<Section> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("phone", phone);
        return sectionMapper.selectCount(queryWrapper);
    }*/

    /*@Override
    public int countByEmail(String email) {
        log.debug("开始执行【根据电子邮箱统计部门的数量】的数据访问，参数：{}", email);
        QueryWrapper<Section> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("email", email);
        return sectionMapper.selectCount(queryWrapper);
    }*/

    @Override
    public SectionStandardVO getStandardById(Long id) {
        log.debug("开始执行【根据ID查询部门详情】的数据访问，参数：{}", id);
        return sectionMapper.getStandardById(id);
    }

    /*@Override
    public SectionLoginInfoVO getLoginInfoBySectionname(String sectionname) {
        log.debug("开始执行【根据部门名查询部门登录信息】的数据访问，参数：{}", sectionname);
        return sectionMapper.getLoginInfoBySectionname(sectionname);
    }
*/
    @Override
    public PageData<SectionListItemVO> list(Integer pageNum, Integer pageSize) {
        log.debug("开始执行【查询部门列表】的数据访问，页码：{}，每页记录数：{}", pageNum, pageSize);
        PageHelper.startPage(pageNum, pageSize);
        List<SectionListItemVO> list = sectionMapper.list();
        PageInfo<SectionListItemVO> pageInfo = new PageInfo<>(list);
        PageData<SectionListItemVO> pageData = PageInfoToPageDataConverter.convert(pageInfo);
        return pageData;
    }

    @Override
    public List<SectionListItemVO> list() {
        log.debug("开始执行【查询部门列表(不分页)】的数据访问");
        return sectionMapper.list();
    }

    @Override
    public List<SectionListItemVO> list(Long parentId) {
        log.debug("开始执行【查询子级部门列表(不分页)】的数据访问");
        return sectionMapper.listByParentId(parentId);
    }

    @Override
    public List<SectionListItemVO> enableList() {
        log.debug("开始执行【查询招聘部门列表】的数据访问");
        return sectionMapper.enableList();
    }

   /* @Override
    public List<SectionListItemVO> regList() {
        log.debug("开始执行【查询注册列表】的数据访问");
        return sectionMapper.regList();
    }*/

    @Override
    public int update(Section section) {
        log.debug("开始执行【更新部门信息】的数据访问，参数：{}", section);
        return sectionMapper.updateById(section);
    }

    @Override
    public int countBySectionNameAndNotId(Long id, String sectionName) {
        log.debug("开始执行【统计匹配ID但不匹配部门名的部门数量】的数据访问，ID：{}，名称：{}", id, sectionName);
        QueryWrapper<Section> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("section_name", sectionName).ne("id", id);
        return sectionMapper.selectCount(queryWrapper);
    }

    @Override
    public Long selectUserIdByRealName(String realName){
        log.debug("开始执行【根据员工姓名查询员工id】的数据访问，realName：{}", realName);
        return userMapper.selectUserIdByRealName(realName);
    }

    @Override
    public Integer selectIsParentById(Long id) {
        log.debug("开始执行【根据id查询isParent】的数据访问，id：{}", id);
        return sectionMapper.selectIsParentById(id);
    }
    @Override
    public Long selectParentIdById(Long id) {
        log.debug("开始执行【根据id查询isParent】的数据访问，id：{}", id);
        return sectionMapper.selectParentIdById(id);
    }

    @Override
    public int childrenSectionCountByParentId(Long parentId) {
        log.debug("开始执行【查询父级部门下的子级部门数量】的数据访问，parentId：{}", parentId);
        QueryWrapper<Section> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id", parentId);
        return sectionMapper.selectCount(queryWrapper);
    }

    @Override
    public int updateParentSectionIsParent(Long parentId) {
        log.debug("开始执行【修改父级部门的isParent为0】的数据访问，parentId：{}", parentId);
        //创建Section对象
        Section section = new Section();
        section.setId(parentId);
        section.setIsParent(0);
        return sectionMapper.updateById(section);
    }

    @Override
    public int countByUserId(Long id) {
        log.debug("开始执行【根据用户id查询head_id数量】的数据访问，参数：{}", id);
        QueryWrapper<Section> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("head_id", id);
        return sectionMapper.selectCount(queryWrapper);
    }

}